package com.yikes.srb.web.utils;

import com.yikes.srb.common.enums.ResultCodeEnum;
import com.yikes.srb.common.enums.ResultCodeInterface;
import com.yikes.srb.common.result.Result;
import com.yikes.srb.web.exception.BizException;
import jakarta.validation.constraints.NotNull;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.Objects;
import java.util.function.Supplier;

/**
 * <p>
 *  断言工具类
 * </p>
 *
 * @Author: guanrong.yin
 * @Date: 2024/12/1 21:56
 */
public class As {


    private As() {}

    /**
     * 断言对象不能为空
     *
     * @param obj 对象
     * @param ex  自定义异常
     */
    public static void isNotNull(Object obj, BizException ex) {

        if (Objects.isNull(obj)) {
            throw ex;
        }
    }


    /**
     * 断言对象不能为空
     *
     * @param obj 对象
     * @param ef  异常输出对象
     */
    public static void isNotNull(Object obj, ResultCodeInterface ef, Object... params) {

        if (Objects.isNull(obj)) {
            throw BizException.build(ef, params);
        }
    }


    /**
     * 断言对象为空
     *
     * @param obj 对象
     * @param ex  自定义异常
     */
    public static void isNull(Object obj, BizException ex) {

        if (Objects.nonNull(obj)) {
            throw ex;
        }
    }


    /**
     * 断言对象为空
     *
     * @param obj    对象
     * @param ef     自定义异常
     * @param params 格外参数
     */
    public static void isNull(Object obj, ResultCodeInterface ef, Object... params) {

        if (Objects.nonNull(obj)) {
            throw BizException.build(ef, params);
        }
    }

    /**
     * 断言字符串不能为空或者空字符串
     *
     * @param str 字符串
     * @param ex  自定义异常
     */
    public static void isNotBlank(String str, BizException ex) {

        if (StringUtils.isBlank(str)) {
            throw ex;
        }
    }


    /**
     * 断言字符串不能为空或者空字符串
     *
     * @param str    字符串
     * @param ef     自定义异常
     * @param params 格外参数
     */
    public static void isNotBlank(String str, ResultCodeInterface ef, Object... params) {

        if (StringUtils.isBlank(str)) {
            throw BizException.build(ef, params);
        }
    }

    /**
     * 断言结果为true
     *
     * @param flag flag
     * @param ex   自定义异常
     */
    public static void isTure(boolean flag, BizException ex) {

        if (Objects.equals(Boolean.FALSE, flag)) {
            throw ex;
        }
    }


    /**
     * 断言结果为true
     *
     * @param flag   flag
     * @param ef     自定义异常
     * @param params 格外参数
     */
    public static void isTure(boolean flag, ResultCodeInterface ef, Object... params) {

        if (Objects.equals(Boolean.FALSE, flag)) {
            throw BizException.build(ef, params);
        }
    }

    /**
     * 断言结果为true
     *
     * @param flag
     * @param ef
     * @param supplier
     */
    public static void isTure(boolean flag, ResultCodeInterface ef, @NotNull Supplier<?> supplier) {

        if (Objects.equals(Boolean.FALSE, flag)) {
            throw BizException.build(ef, supplier.get());
        }
    }


    /**
     * 断言返回结果为 正常
     *
     * @param resp 服务调用响应结果
     */
    public static <T> void isSuccess(Result<T> resp) throws Exception {

        if (!ResultCodeEnum.SUCCESS.getCode().equals(resp.getCode())) {
            throw BizException.build(ResultCodeEnum.SYSTEM_EXECUTION_ERROR);
        }
    }

    /**
     * 断言两个对象相对
     *
     * @param obj1
     * @param obj2
     * @param ex
     */
    public static void isEq(Object obj1, Object obj2, BizException ex) {

        if (!Objects.equals(obj1, obj2)) {
            throw ex;
        }

    }

    /**
     * 断言两个对象相对
     *
     * @param obj1
     * @param obj2
     * @param ef
     * @param params
     */
    public static void isEq(Object obj1, Object obj2, ResultCodeInterface ef, Object... params) {

        if (!Objects.equals(obj1, obj2)) {
            throw BizException.build(ef, params);
        }

    }

    /**
     * 断言集合为空
     *
     * @param list
     * @param ex
     * @param <T>
     */
    public static <T> void isEmpty(Collection<T> list, BizException ex) {

        if (!CollectionUtils.isEmpty(list)) {
            throw ex;
        }
    }

    /**
     * 断言集合为空
     *
     * @param list
     * @param ef
     * @param params
     * @param <T>
     */
    public static <T> void isEmpty(Collection<T> list, ResultCodeInterface ef, Object... params) {

        if (!CollectionUtils.isEmpty(list)) {
            throw BizException.build(ef, params);
        }
    }

    /**
     * 断言集合不为空
     *
     * @param list
     * @param ex
     * @param <T>
     */
    public static <T> void isNotEmpty(Collection<T> list, BizException ex) {

        if (CollectionUtils.isEmpty(list)) {
            throw ex;
        }
    }

    /**
     * 断言集合不为空
     *
     * @param list
     * @param ef
     * @param params
     * @param <T>
     */
    public static <T> void isNotEmpty(Collection<T> list, ResultCodeInterface ef, Object... params) {

        if (CollectionUtils.isEmpty(list)) {
            throw BizException.build(ef, params);
        }
    }


    /**
     * 直接抛出错误
     *
     * @param ef
     * @param params
     */
    public static void throwEx(ResultCodeInterface ef, Object... params) {

        throw BizException.build(ef, params);
    }

}
